package solutions.ferpa.ztest.ent;

import java.sql.*;
import java.util.ArrayList;
import br.com.telescope.adsrt.dom.*;
import br.com.telescope.adsrt.lib.*;
import br.com.telescope.t2.exception.Severity;

/**
 * API de persistência de dados da entidade INTERFACES_SISTEMAS
 * @author Gerado pelo Telescope
 */
public class EntInterfacesSistemas extends Entity {
    
    public final static String ENTITY_NAME = "RTSYSINF.INTERFACES_SISTEMAS";
    public final static String TABLE_NAME = "INTERFACES_SISTEMAS";
    
    // <editor-fold defaultstate="collapsed" desc="Contrutores e inicializacao">
    /**
     * Construtores
     */
    public EntInterfacesSistemas() {
        super();
        initialize();
    }
    
    public EntInterfacesSistemas(BaseRuntime ctx) {
        super();
        initialize(ctx);
    }
    
    @Override
    public String getPrimaryKeyColumn() {
        return "ID";
    }
    
    @Override
    public void initialize(BaseRuntime ctx) {
        super.initialize(ctx);
        initialize();
    }
    
    public void initialize() {
        aId = new DomId(this,"ID", "Id"); 
        aId.setRequired(true);
        oId = new DomId();
        aNome = new DomUpper(this,"NOME", "Nome da Interface"); 
        aNome.setRequired(true);
        aNome.setSize(80);
        oNome = new DomUpper();
        aTitulo = new DomText(this,"TITULO", "Título"); 
        aTitulo.setRequired(true);
        aTitulo.setSize(160);
        oTitulo = new DomText();
        aTipoRegistro = new DomOpcao(this,"TIPO_REGISTRO", "Tipo de registro"); 
        aTipoRegistro.setRequired(true);
        aTipoRegistro.setSize(13);
        aTipoRegistro.clearOptions();
        aTipoRegistro.addOption("I", "Implementação Custom");
        aTipoRegistro.addOption("PA_ATIVIDADES", "Política de acesso para atividades");
        aTipoRegistro.addOption("U", "User Interface");
        aTipoRegistro.setDefaultValue("U");
        oTipoRegistro = new DomOpcao();
        ressetModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributos da entidade">
    
    // Id
    private DomId aId;
    private DomId oId;
    
    // Nome da Interface
    private DomUpper aNome;
    private DomUpper oNome;
    
    // Título
    private DomText aTitulo;
    private DomText oTitulo;
    
    // Tipo de registro
    private DomOpcao aTipoRegistro;
    private DomOpcao oTipoRegistro;
    
    // <editor-fold defaultstate="collapsed" desc="Atributo ID">
    
    public EntInterfacesSistemas id(Long value) {
        setId(value);
        return this;
    }
    
    public void setId(DomId value) {
        if (value == null || value.isNull()) {
            nullifyId();
        } else {
            aId.setValue(value.getValue());
            if (aId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setId(String value) {
        if (value == null) {
            nullifyId();
        } else {
            aId.setValue(value);
            if (aId.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setId(Long value) {
        aId.setValue(value);
        if (aId.isModified()) {
            setModified(true);
        }
    }
    
    public void setId(Object value) {
        aId.setValue(value);
        if (aId.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyId() {
        if (!aId.isNull()) {
            aId.setNull(true);
            setModified(true);
        }
    }
    
    public DomId getId() {
        return aId;
    }
    
    public DomId oldId() {
        return oId;
    }
    
    public Long valueOfId() {
        return aId.getValue();
    }
    
    public boolean isIdModified() {
        return aId.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo NOME">
    
    public EntInterfacesSistemas nome(String value) {
        setNome(value);
        return this;
    }
    
    public void setNome(DomUpper value) {
        if (value == null || value.isNull()) {
            nullifyNome();
        } else {
            aNome.setValue(value.getValue());
            if (aNome.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setNome(String value) {
        if (value == null) {
            nullifyNome();
        } else {
            aNome.setValue(value);
            if (aNome.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setNome(Object value) {
        aNome.setValue(value);
        if (aNome.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyNome() {
        if (!aNome.isNull()) {
            aNome.setNull(true);
            setModified(true);
        }
    }
    
    public DomUpper getNome() {
        return aNome;
    }
    
    public DomUpper oldNome() {
        return oNome;
    }
    
    public String valueOfNome() {
        return aNome.getValue();
    }
    
    public boolean isNomeModified() {
        return aNome.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo TITULO">
    
    public EntInterfacesSistemas titulo(String value) {
        setTitulo(value);
        return this;
    }
    
    public void setTitulo(DomText value) {
        if (value == null || value.isNull()) {
            nullifyTitulo();
        } else {
            aTitulo.setValue(value.getValue());
            if (aTitulo.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setTitulo(String value) {
        if (value == null) {
            nullifyTitulo();
        } else {
            aTitulo.setValue(value);
            if (aTitulo.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setTitulo(Object value) {
        aTitulo.setValue(value);
        if (aTitulo.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyTitulo() {
        if (!aTitulo.isNull()) {
            aTitulo.setNull(true);
            setModified(true);
        }
    }
    
    public DomText getTitulo() {
        return aTitulo;
    }
    
    public DomText oldTitulo() {
        return oTitulo;
    }
    
    public String valueOfTitulo() {
        return aTitulo.getValue();
    }
    
    public boolean isTituloModified() {
        return aTitulo.isModified();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Atributo TIPO_REGISTRO">
    
    public EntInterfacesSistemas tipoRegistro(String value) {
        setTipoRegistro(value);
        return this;
    }
    
    public void setTipoRegistro(DomOpcao value) {
        if (value == null || value.isNull()) {
            nullifyTipoRegistro();
        } else {
            aTipoRegistro.setValue(value.getValue());
            if (aTipoRegistro.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setTipoRegistro(String value) {
        if (value == null) {
            nullifyTipoRegistro();
        } else {
            aTipoRegistro.setValue(value);
            if (aTipoRegistro.isModified()) {
                setModified(true);
            }
        }
    }
    
    public void setTipoRegistro(Object value) {
        aTipoRegistro.setValue(value);
        if (aTipoRegistro.isModified()) {
            setModified(true);
        }
    }
    
    public void nullifyTipoRegistro() {
        if (!aTipoRegistro.isNull()) {
            aTipoRegistro.setNull(true);
            setModified(true);
        }
    }
    
    public DomOpcao getTipoRegistro() {
        return aTipoRegistro;
    }
    
    public DomOpcao oldTipoRegistro() {
        return oTipoRegistro;
    }
    
    public String valueOfTipoRegistro() {
        return aTipoRegistro.getValue();
    }
    
    public boolean isTipoRegistroModified() {
        return aTipoRegistro.isModified();
    }
    // </editor-fold>
    // </editor-fold>
    
    @Override
    protected void processDeleteRestrict() throws AdsException {
        // Nullify cascade RTMENU.ITENS_MENUS.FK_INTERFACE_ITME
        {
            EntItensMenus external = new EntItensMenus(ctx);
            external.findByInterface(valueOfId());
            if (external.next()) {
                throw new AdsException("RTMENU.ITENS_MENUS.FK_INTERFACE_ITME.RESTRICTED",
                        AdsException.ERROR,
                        "Não pode excluir porque existem Itens de menus fazendo referencia para este registro");
            }
            external.close();
        }
    }
    
    @Override
    protected void processDeleteCascade() throws AdsException {
        // Delete cascade RTSYSINF.INTERFACES_FUNCOES.FK_INTERFACE
        {
            EntInterfacesFuncoes interfacesFuncoes = new EntInterfacesFuncoes(ctx);
            interfacesFuncoes.del("select id from INTERFACES_FUNCOES where INTERFACE_ID = " + valueOfId());
        }
        // Delete cascade RTSYSINF.OPERACOES_SISTEMAS.FK_OPRSIS_INTERFACE
        {
            EntOperacoesSistemas operacoesSistemas = new EntOperacoesSistemas(ctx);
            operacoesSistemas.del("select id from OPERACOES_SISTEMAS where INTERFACE_ID = " + valueOfId());
        }
    }
    
    // <editor-fold defaultstate="collapsed" desc="getErrors">
    /**
     * Traduz um erro recebido do banco de dados para um AdsException
     */
    @Override
    public AdsException getErrors(String errorMsg, int transaction) {
        AdsException e;
        String msg = errorMsg.toUpperCase();
        
        if (transaction == DELETE_TRANSACTION) {
            if (msg.indexOf("FK_TATIVI_INTSIS_POLITICA_ACESSO") >= 0) {
                e = new AdsException("FSPROJETOS.TIPO_ATIVIDADE.FK_TATIVI_INTSIS_POLITICA_ACESSO.RESTRICTED", 
                        Severity.ERROR,
                        "Não pode excluir porque existem Tipos de Atividades fazendo referencia para este registro! (FK_TATIVI_INTSIS_POLITICA_ACESSO)");
                return e;
            } else if (msg.indexOf("FK_INTERFACE_ITME") >= 0) {
                e = new AdsException("RTMENU.ITENS_MENUS.FK_INTERFACE_ITME.RESTRICTED", 
                        Severity.ERROR,
                        "Não pode excluir porque existem Itens de menus fazendo referencia para este registro! (FK_INTERFACE_ITME)");
                return e;
            } else if (msg.indexOf("FK_TATIVI_INTSIS_POLITICA_ACESSO") >= 0) {
                e = new AdsException("PROJET.TIPOS_ATIVIDADES.FK_TATIVI_INTSIS_POLITICA_ACESSO.RESTRICTED", 
                        Severity.ERROR,
                        "Não pode excluir porque existem Tipos de Atividades fazendo referencia para este registro! (FK_TATIVI_INTSIS_POLITICA_ACESSO)");
                return e;
            } else if (msg.indexOf("FK_ITME_INTSIS_INTERFACE") >= 0) {
                e = new AdsException("ADSRT_OLD.ITENS_MENUS.FK_ITME_INTSIS_INTERFACE.RESTRICTED", 
                        Severity.ERROR,
                        "Não pode excluir porque existem Ítens de menus fazendo referencia para este registro! (FK_ITME_INTSIS_INTERFACE)");
                return e;
            } else if (msg.indexOf("FK_TEIT_INTERFACE") >= 0) {
                e = new AdsException("FRIGAPP.TEXTOS_INTRANET.FK_TEIT_INTERFACE.RESTRICTED", 
                        Severity.ERROR,
                        "Não pode excluir porque existem Textos para intranet fazendo referencia para este registro! (FK_TEIT_INTERFACE)");
                return e;
            } else {
                e = new AdsException("RTSYSINF.INTERFACES_SISTEMAS.GET_ERRORS_UNKNOWN",
                        AdsException.UNKNOWN,
                        "Erro não esperado: " + errorMsg);
            }
        } else {
            if (msg.indexOf("UK_INTERFACE") >= 0) {
                e = new AdsException("RTSYSINF.INTERFACES_SISTEMAS.UK_INTERFACE", 
                        Severity.ERROR,
                        "Registro duplicado! O nome da interface/serviço não pode ser duplicado! Nome da Interface ${NOME} (UK_INTERFACE)");
                return e;
            } else if (msg.indexOf("PK_INTSIS") >= 0) {
                e = new AdsException("RTSYSINF.INTERFACES_SISTEMAS.PK_INTSIS", 
                        Severity.ERROR,
                        "ID duplicado! (PK_INTSIS)");
                return e;
            } else {
                e = new AdsException("RTSYSINF.INTERFACES_SISTEMAS.GET_ERRORS_UNKNOWN",
                        AdsException.UNKNOWN,
                        "Erro não esperado: " + errorMsg);
            }
        }
        return e;
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Entity Information">
    
    public String getEntityName() {
        return ENTITY_NAME;
    }
    
    public String getTableName() {
        return TABLE_NAME;
    }
    
    public String idSequenceName() {
        return "PK_SEQUENCE";
    }
    
    private ArrayList<Field> allAttributes;
    public ArrayList<Field> getAllAttributes() {
        if (allAttributes == null) {
            allAttributes = new ArrayList<Field>();
            allAttributes.add(aId);
            allAttributes.add(aNome);
            allAttributes.add(aTitulo);
            allAttributes.add(aTipoRegistro);
        }
        return allAttributes;
    }
    
    /**
     * Retorna o valor da primeira UK da entidade
     * Se ela for composta, retorna a concatenação de toda a combinação
     * de atributos separados por um espaço.
     */
    public String valueOfUk() {
        return getNome().toString();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Relationships">
    
    
    public void findByNome(String nome) throws AdsException {
        findBy(new String[] {"NOME"},
                new Object[] {nome});
    }
    /**
     * Retorna os registros de INTERFACES_FUNCOES que referenciam este registro através do atributo INTERFACE_ID
     */
    public EntInterfacesFuncoes findAllInterfacesFuncoesInterface() throws AdsException {
        return findAllInterfacesFuncoesInterface("order by ID");
    }
    
    /**
     * Retorna os registros de INTERFACES_FUNCOES que referenciam este registro através do atributo INTERFACE_ID
     */
    public EntInterfacesFuncoes findAllInterfacesFuncoesInterface(String sqlAppend) throws AdsException {
        EntInterfacesFuncoes out = new EntInterfacesFuncoes(ctx);
        out.find("select ID from INTERFACES_FUNCOES where INTERFACE_ID = " + valueOfId() + " " + sqlAppend);
        return out;
    }
    
    /**
     * Retorna os registros de OPERACOES_SISTEMAS que referenciam este registro através do atributo INTERFACE_ID
     */
    public EntOperacoesSistemas findAllOperacoesSistemasInterface() throws AdsException {
        return findAllOperacoesSistemasInterface("order by ID");
    }
    
    /**
     * Retorna os registros de OPERACOES_SISTEMAS que referenciam este registro através do atributo INTERFACE_ID
     */
    public EntOperacoesSistemas findAllOperacoesSistemasInterface(String sqlAppend) throws AdsException {
        EntOperacoesSistemas out = new EntOperacoesSistemas(ctx);
        out.find("select ID from OPERACOES_SISTEMAS where INTERFACE_ID = " + valueOfId() + " " + sqlAppend);
        return out;
    }
    
    /**
     * Retorna os registros de ITENS_MENUS que referenciam este registro através do atributo INTERFACE_ID
     */
    public EntItensMenus findAllItensMenusInterface() throws AdsException {
        return findAllItensMenusInterface("order by ID");
    }
    
    /**
     * Retorna os registros de ITENS_MENUS que referenciam este registro através do atributo INTERFACE_ID
     */
    public EntItensMenus findAllItensMenusInterface(String sqlAppend) throws AdsException {
        EntItensMenus out = new EntItensMenus(ctx);
        out.find("select ID from ITENS_MENUS where INTERFACE_ID = " + valueOfId() + " " + sqlAppend);
        return out;
    }
    
    
    /**
     * Método que copia os valores dos atributos
     * para os valores respectivos old 
     */
    public void saveOldAtributes() {
        oId.setValue(aId);
        oTitulo.setValue(aTitulo);
        oTipoRegistro.setValue(aTipoRegistro);
        oNome.setValue(aNome);
    }
    
    /**
     * Método que retorna as regras da entidade
     * @return ArrayList com as regras ou null caso não existir nenhuma regra
     */
    public ArrayList getAllRules() {
        ArrayList<EntityRule> out = new ArrayList<EntityRule>();
        {
            PrimaryKeyRule rule = new PrimaryKeyRule();
            rule.setEntity(EntInterfacesSistemas.class);
            rule.setName("PK_INTSIS");
            rule.setPkAttribute(new DomId("ID",""));
            out.add(rule);
        }
        {
            UniqueKeyRule rule = new UniqueKeyRule();
            rule.setEntity(EntInterfacesSistemas.class);
            rule.setName("UK_INTERFACE");
            rule.addAttribute(new DomUpper("NOME",""));
            out.add(rule);
        }
        {
            AllowableValuesRule rule = new AllowableValuesRule();
            rule.setEntity(EntInterfacesSistemas.class);
            rule.setCheckAttribute(new DomOpcao("TIPO_REGISTRO",""));
            rule.setName("CKAV_2230723");
            rule.addAllowableValues(new String[] {"I", "PA_ATIVIDADES", "U"});
            out.add(rule);
        }
        return out;
    }
    // </editor-fold>
    
    @Override
    public void fillDefaultValues() throws AdsException {
        if (aId.isNull()) {
            aId.setValue("" + ctx.getNextVal("pk_sequence"));
        }
        if (getTipoRegistro().isNull()) {
            setTipoRegistro(getTipoRegistro().getDefaultValue());
        }
    }
    
    // <editor-fold defaultstate="collapsed" desc="Métodos customizados">
    
    /**
     * user has access to interface.
     * <p>
     * Verifica se o usuário tem (ou não) acesso à interface.
     */
    public boolean userHasAccessToInterface() throws AdsException {
        // <user-code id="752853" parentId="309306" hashcode="-25b51683" length="14">
        return true;
        
        // </user-code>
    }
}
